\chapter{Dise\~no e Implementaci\'on}

\label{disenio}

\section{Introducci\'on}
El dise\~no es un proceso que usa los resultados del an\'alisis para generar una especificaci\'on que implemente los requerimientos. El dise\~no trabaja en el ``espacio de la soluci\'on''.\\
Un buen dise\~no ayuda a crear software con propiedades deseables, como reusabilidad, mantenibilidad, portabilidad, etc.\\
El resultado del dise\~no ser\'a la base de la implementaci\'on del sistema. \cite{AnalysisAndDesign}\\ 

\section{Conceptos del Dise\~no (\textbf{DOO})}
En esta secci\'on introduciremos algunos conceptos sobre el modelo orientado a objetos utilizado para el desarrollo de este trabajo.

\subsection{Dise\~no Orientado a Objetos}
El dise\~no Orientado a Objetos toma los resultados del an\'alisis con el fin de generar un modelo lo bastante
detallado como para ser implementado en un lenguaje Orientado a Objetos.\\

Todo modelo de diseño Orientado a Objetos especifica lo siguiente:
\begin{itemize}
	\item Los tipos de objetos (clases) que necesita el sistema para resolver el problema. Deben 			 
		especificarse sus atributos, operaciones y relaciones.
	\item Las interacciones entre los objetos (instancias de las clases).
\end{itemize}
El primer punto corresponde al modelo est\'atico; el segundo, al din\'amico.

\section{Programaci\'on Orientada a Objetos}
La Programaci\'on Orientada a Objetos (\textbf{POO})\cite{POO} es un paradigma de programaci\'on que define los programas en t\'erminos de ``clases de objetos'', objetos que son entidades que combinan estado (propiedades o datos), comportamiento (procedimientos o m\'etodos) e identidad (propiedad del objeto que lo diferencia del resto).\\

La programaci\'on orientada a objetos expresa un programa como un conjunto de estos objetos, que colaboran entre ellos para realizar tareas. Esto permite hacer los programas y m\'odulos m\'as f\'aciles de escribir, mantener y reutilizar.\\

Un \textbf{objeto} contiene toda la informaci\'on que permite definirlo e identificarlo frente a otros objetos pertenecientes a otras clases (e incluso entre objetos de una misma clase, al poder tener valores bien diferenciados en sus atributos). A su vez, dispone de mecanismos de interacci\'on (los llamados m\'etodos) que favorecen la comunicaci\'on entre objetos (de una misma clase o de distintas), y en consecuencia, el cambio de estado en los propios objetos. Esta caracter\'istica lleva a tratarlos como unidades indivisibles, en las que no se separan (ni deben separarse) informaci\'on (datos) y procesamiento (m\'etodos).La operaci\'on que crea e inicializa un objeto es llamada \textbf{constructor}, mientras
que aquella encargada de destruirlo es llamada \textbf{destructor}.\\

Las \textbf{clases} son declaraciones o abstracciones de objetos, lo que significa, que una clase es la definición de un objeto.\\

Algunos conceptos de la programaci\'on Orientada a Objetos son:

\begin{itemize}
	\item \textbf{Abstracci\'on}: Consiste en la generalizaci\'on conceptual de un determinado conjunto de 						objetos y de sus atributos y propiedades, dejando en un segundo t\'ermino los detalles 							concretos de cada objeto.
	\item \textbf{Herencia}: Las clases no est\'an aisladas, sino que se relacionan entre s\'i, formando una 									jerarqu\'ia de clasificaci\'on. Los objetos heredan las propiedades y el comportamiento de 							todas las clases a las que pertenecen. La herencia organiza y facilita el 					
						encapsulamiento permitiendo a los objetos ser definidos y creados como tipos especializados 						de objetos preexistentes. Estos pueden compartir (y extender) su comportamiento sin tener 							que reimplementarlo por completo. 
	\item \textbf{Polimorfismo}: Se refiere a la posibilidad de acceder a un variado rango de funciones distintas a trav\'es del mismo interfaz. O sea, que, en la pr\'actica, un mismo identificador puede tener distintas formas (distintos cuerpos de funci\'on, distintos comportamientos) dependiendo, en general, del contexto en el que se halle. 
\end{itemize}

\section{Herramientas}
En el proceso de desarrollo de este trabajo se utilizaran herramientas bajo licencias catalogadas como Software Libre por la FSF (free software foundation). A continuaci\'on se enumera una lista de ellas.

\subsection{GNU Toolchain}
Este proyecto ser\'a realizado bajo el sistema operativo GNU/Linux, \'este cuenta con una serie de herramientas de gran utilidad e importancia, las m\'as relevantes para \'este trabajo son:

\begin{itemize}
	\item \textbf{GCC (GNU Compiler Collection)}: Es un conjunto de compiladores creados por el proyecto 	 
				GNU. GCC es software libre y se distribuye bajo licencia GPL. Estos compiladores se 
				consideran est\'andar para sistemas operativos derivados de GNU 	
				\footnote{http://gcc.gnu.org/}.
	\item \textbf{GDB (GNU Debugger)}: Es un depurador portable que se puede utilizar en varias									plataformas Unix y funciona para varios lenguajes de programaci\'on como C y C++ entre 
				otros. GDB fue escrito por Richard Stallman en 1988, es software libre y se distribuye bajo 
				licencia GPL \footnote{www.gnu.org/software/gdb/}.
\end{itemize} 

\subsection{El Lenguaje C++}
\textbf{\textit{C++}}\cite{cplusplus} es un lenguaje de programaci\'on dise\~nado a mediados de los a\~nos 1980 por Bjarne Stroustrup, su nombre fue propuesto por Rick Mascitti en el a\~no 1983 cuando el lenguaje fue utilizado por primera vez fuera de un laboratorio cient\'ifico.La intenci\'on de su creaci\'on fue el extender al exitoso lenguaje de programación C con mecanismos que permitan la manipulaci\'on de objetos.\\
Posteriormente se a\~nadieron facilidades de programaci\'on gen\'erica, que se sum\'o a los otros dos paradigmas que ya estaban admitidos (programación estructurada y la programación orientada a objetos), por esto se suele decir que  C++ es un lenguaje de programaci\'on multiparadigma.
Una particularidad C++ es la posibilidad de redefinir los operadores, y de poder crear nuevos tipos que se comporten como tipos fundamentales.

\subsection{LATEX}
Todo este documento fue escrito en \LaTeX\footnote{http://www.latex\-project.org/}. Leslie Lamport en 1984, con la intenci\'on de facilitar el uso de TEX (lenguaje de composici\'on tipogr\'afica, creado por Donald Knuth), cre\'o un sistema de composici\'on de textos. El mismo est\'a orientado especialmente a la creaci\'on de libros, documentos cient\'ificos y t\'enicos que contengan f\'ormulas matem\'aticas. A dicho sistema lo llam\'o \LaTeX y est\'a formado por un gran conjunto de macros de \TeX.

\subsection{Edici\'on de texto}
\begin{itemize}
	\item \textbf{Gedit}: Editor de texto plano \footnote{http://projects.gnome.org/gedit/}.
	\item \textbf{Texmaker}: Editor para \LaTeX \footnote{http://xm1math.net/texmaker/}.
\end{itemize}

\subsection{Edici\'on de gr\'aficos}
\begin{itemize}
	\item \textbf{Gimp}: Editor de im\'agenes \footnote{www.gimp.org}.
	\item \textbf{LatexDraw}: Editor de dibujos para \LaTeX \footnote{http://latexdraw.sourceforge.net}.
	\item \textbf{Dia}: Editor de diagramas de prop\'osito general \footnote{http://live.gnome.org/Dia}.
\end{itemize}

\subsection{Documentaci\'on}
\begin{itemize}
	\item \textbf{Doxygen}: Generador de documentaci\'on para m\'ultiples lenguajes 			
	\footnote{www.doxygen.org}.
\end{itemize}

\section{Soluci\'on Propuesta}
\label{SP}
Dados los \textbf{R}equerimientos \textbf{F}uncionales planteados en el cap\'itulo \ref{RF} describiremos una secuencia de pasos que dan soluci\'on a los mismos, respetando los principios definidos en el cap\'itulo \ref{solid}.\\

Como entrada a la soluci\'on se obtienen todos los \textit{ARVs} existentes en la Base de Datos de \textit{LAV}, detallando su representaci\'on en el cap\'itulo \ref{representacionARVs}.

\begin{itemize}
	\item[1-]Tomando todas las resistencias pertenecientes a los \textit{ARVs} de la Base de Datos, se 	  
	         agrupan todos los amino\'acidos que apliquen en la misma posici\'on, obteniendo una lista de 
	         elementos de la forma: \{\textit{posici\'on}, \textit{lista\_Amino\'acidos\_Codones}\}.\\ 
	         \\
	         Formalmente: $\alpha = [(\textit{posici\'on}_{1}, \textit{lista\_Amino\'acidos\_Codones}_{1})
	          				.. (\textit{posici\'on}_{n}, \textit{lista\_Amino\'acidos\_Codones}_{n})]$\\
	          				donde, $ \textit{lista\_Amino\'acidos\_Codones}:[(aminoacido_{1}, codones_{1})
	          				 .. (aminoacido_{m}, codones_{m})]$\\
	          				y $\textit{codones}_i$ es una lista de: $\texttt{(a|u|c|g; a|u|c|g; a|u|c|g)}_{i}$ que 
	          				codifican a $aminoacido_{i}$ con $1\leq i \leq m$, siendo \texttt{a, u, c, g} nucle\'otidos.\\
	\item[2-]Una \textit{mutante} es representada por un n\'umero en base mixta 
			\footnote{http://es.wikipedia.org/wiki/Ra\'iz\_mixta}, donde: \\
			\begin{itemize}
				\item[2.1-]La cantidad de bases del n\'umero(\textit{mutante}) es igual a la cantidad de 
							elementos de $\alpha$ (lista del punto anterior).
				\item[2.2-]Cada base va a estar determinada por la cantidad de \textit{codones} en cada 
							\textit{posici\'on} m\'as uno.  
			\end{itemize}
			Formalmente: $\forall \textit{a}_{i} \in \alpha: (\#\alpha = \textit{\#bases}) \wedge 
							(\textit{base}_{i} = (\textit{\#codones}_{i} \in \textit{b}_{i})+1)$ 
							con $1 \leq i \leq \#\alpha$ \\
	\item[3-]La cantidad de mutantes posibles, es igual a la productoria de todas las bases menos uno, \'esto 
	        resuelve el \textbf{RF1}, formalmente:\\\\ 
			$\beta = \{\textit{mutante}_{1},..,\textit{mutante}_{n}\}/
			1\leq n \leq (\prod_{1}^{\textit{\#bases}}{\textit{base}})-1$\\
			donde cada $\textit{mutante}_{r}$ con $1 \leq r \leq n$ es un n\'umero en base mixta, 
			formalmente:  
			
			$\textit{mutante}_{r} = x_{j}...x_{1} / 0 \leq x_{j} < \textit{base}_{j} \wedge 
			0 \leq x_{1} < \textit{base}_{1}$ con $1 \leq j \leq \textit{\#bases}$ \\
			Cada $x_{k}$ en $x_{j}...x_{1}$ con $1\leq k \leq j$ representa un cod\'on de 
			$\textit{lista\_Amino\'acidos\_Codones}_{i}$, es decir: si $x_{k}$ = 1 entonces representa al primer 				elemento (cod\'on) de \textit{codones} en $\textit{lista\_Amino\'acidos\_Codones}_{i}$. 
			Si $x_{k}$ = 2 entonces representa al segundo elemento (cod\'on) de \textit{codones} en 							$\textit{lista\_Amino\'acidos\_Codones}_{i}$.\\
			Vale aclarar que $x_{k}$ = 0 no representa ning\'un elemento de \textit{codones}.
	\item[4-]El \textbf{RF3} propone que dada una mutante, se retorne su identificador.	\\
			Cada identificador ser\'a calculado a trav\'es de los siguientes pasos:\\		
			\begin{itemize}
				\item[4.1-]A partir de las bases (definido en el punto 2.2) que determina a cada mutante,
							se calcula un vector de coeficientes, donde el primer valor siempre es 1 y los 										restantes resultan de multiplicar el coeficiente anterior por la base anterior,
							tal como se muestra a continuaci\'on:
				\begin{lstlisting}[language=C++,keywordstyle=\color{blue}, 
									morekeywords={in, out, each}]
void get_coefficients(in:bases, out:coefficients)
{
    coefficients[0]=1;
    for(i=1; i< #bases; ++i)
    {
        coefficients[i]=coefficients[i-1]*bases[#bases - i];
    }
}
				\end{lstlisting}
				\item[4.2-]Una vez obtenido el vector de coeficientes es posible calcular un identificador (id) 								para cada mutante con la que se va a trabajar:\\
							Teniendo en cuenta que una mutante es una secuencia de valores en base mixta 										y el vector de coeficientes calculado anteriormente, se define una funci\'on que 									calcula para cada mutante dada:
				\begin{lstlisting}[language=C++,keywordstyle=\color{blue}, 
									morekeywords={in, out, each}]
Id get_id(in:mutant)
{
    size_t id=0;
    for(size_t i=1; i<= #coefficients; ++i)
    {
        id += mutant[i-1]*coefficients[#coefficients-i];
    }
    return id;
}
				\end{lstlisting}
			\end{itemize}
	\item[5-]El \textbf{RF2} propone que dado un identificador, se retorne la mutante al que \'este hace 
			referencia.\\
			Dado un \emph{id}:\\
			\begin{itemize}
				\item[5.1-]Se divide dicho \emph{id} por la \'ultima base.
				\item[5.2-]El cociente obtenido del paso anterior se divide por la siguiente base (se repite el 							   proceso de dividir los cocientes, hasta llegar a la primera base).
				\item[5.3-]Por \'ultimo se agrega el cociente resultante en la ultima divisi\'on.
						   Aclaraci\'on: los valores que forman la mutante son almacenados empezando en la 								   posici\'on \textit{\#base} hasta la posici\'on 0.
				\begin{lstlisting}[language=C++,keywordstyle=\color{blue}, 
									morekeywords={in, out, each}]
void get_mutant(in:id, out:mutant)
{
    int cociente = id;
    for(i= #base; i>1; --i)
    {
        mutant[i-1] = cociente % base[i-1];
        cociente /= base[i-1];
    }
   	mutant[0] = cociente;
}
				\end{lstlisting}
						   
			\end{itemize}
			\item[6-]El \textbf{RF4} propone calcular a partir de un identificador, el conjunto de antivirales 						     a los cuales es sensible la mutante representada por dicho identificador.\\
					 En este punto se define la primer funci\'on de la relaci\'on, teniendo como dominio los 							 identificadores de todas las posibles mutantes y como imagen el conjunto 											 \textit{\textbf{$\mathcal{P}$(ARVs)}}.\\
					 Dado un id:
					 \begin{itemize}
					 \item[6.1-]Se obtiene la mutante que representa dicho id (definido en el punto 5).
					 \item[6.2-]A partir de la mutante obtenida en el paso anterior y teniendo en cuenta que 										\'esta es una secuencia de valores en base mixta, se obtienen los codones 											representados por cada valor que forma dicha mutante y la posici\'on de \'este 									dentro de la misma (de acuerdo al paso 1 y 2), dando como resultado una lista 										\textit{(L)} de elementos:(\textit{posici\'on,$\texttt{(a|u|c|g; a|u|c|g; a|u|c|g)}$}).\\
					 			Formalmente:\\
					 			mutant = $x_{j}...x_{1} / 1\leq j \leq \#base$ donde a partir de cada $x_{k}$ se 									obtiene $\texttt{(a|u|c|g; a|u|c|g; a|u|c|g)}$ con $1\leq k \leq j$.\\
					 			\textit{\textbf{L}} = $[(posicion_{j},\texttt{(a|u|c|g; a|u|c|g; a|u|c|g)}_{j}),..,														 (posicion_{1},\texttt{(a|u|c|g; a|u|c|g; a|u|c|g)}_{1})]$
					\item[6.3-]Por \'ultimo, se recorre cada elemento de la lista \textit{\textbf{L}} comparando 									la \textit{posici\'on} de cada cod\'on con la posici\'on de resistencia de cada 
								antiviral en la Base de Datos. En caso que coincidan ambas posiciones, se 
								obtienen los codones que codifican al amino\'acido de la resistencia y se calcula 
								la distancia gen\'etica de cada cod\'on obtenido con el cod\'on de la mutante. En 								caso en que la distancia gen\'etica entre codones sea 0, se elimina del conjunto 									resultado el antiviral al que pertenece dicha resistencia.\\
					 			\textit{\textbf{Aclaraci\'on}:} la distancia gen\'etica compara los nucle\'otidos 
					 			de acuerdo a la posici\'on que ocupan en el 
					 			cod\'on. Si los tres nucle\'otidos son iguales, la distancia es 0, si s\'olo dos de 
					 			ellos son iguales, la distancia es 1, si s\'olo uno de ellos es igual, la distancia 
					 			es 2 y si los tres son distintos, la distancia es 3.
					 \end{itemize}
					 \begin{lstlisting}[language=C++,keywordstyle=\color{blue}, 
							morekeywords={in, out, each}]
void get_applicable(in: id, out: applicable_antivirals)
{
    get_mutant(id, mutant);
    mutant_to_triplets(mutant, triplet_position_container);
    for (av = antivirals.begin(); av != antivirals.end(); ++av)
    {
        if (((av)->min_dist_to_antiviral(triplet_position_container)) > 0)
        {
            insert_into(applicable_antivirals, av);
        }
    }
}

void mutant_to_triplets(in: mutant, join_antivirals, out: triplets_positions)
{
    Triplet current_triplet;
    for (size_t i = 0; i < mutant.size(); ++i)
    {
        if (mutant[i] > 0)
        {
            join_antivirals[i].get_triplet_in_value(mutant[i], current_triplet);
            TripletPosition current_pos_triplet(join_antivirals[i].pos_resistence, 
            current_triplet);
            insert_into(triplets_positions, current_pos_triplet);
        }
    }
}
			\end{lstlisting}
			\item[7-]El \textbf{RF5} propone que a partir de un identificador y un conjunto de antivirales 
					aplicables a dicho identificador, retorne el conjunto de identificadores (que representan a 
					las mutantes) que resultan luego de dicha aplicaci\'on.\\
			 		En este punto se define la segunda funci\'on de la relaci\'on, teniendo como dominio a 
			 		\textit{\textbf{$\mathcal{P}$(ARVs)}} y como imagen el conjunto de \textbf{IDs} de todas las 
			 		posibles mutantes.\\
					Dado un \emph{id} (que representa a una mutante) y un conjunto de \textit{ARVs} que aplican a 
					\'este:
					\begin{itemize}
						\item[7.1-]Se obtiene la \textit{mutante} que representa dicho id 
									(definido en el punto 5).
						\item[7.2-]Se generan las combinaciones de \textit{ARVs}.\ref{combinacion_arvs}
						\item[7.3-]Para cada combinaci\'on del paso anterior, se obtienen los valores que		
									representan (valor en \textit{codones}, paso 1) a cada cod\'on y se 
									reemplazan dichos valores en la \textit{mutante} original.
						\item[7.4-]Para cada nueva \textit{mutante} obtenida del paso anterior, se calcula su 	
									\emph{id} (seg\'un paso 4.2) y se lo agrega al conjunto resultado.
					\end{itemize}
					\begin{lstlisting}[language=C++,keywordstyle=\color{blue}, 
					       morekeywords={in, out, each}]
void get_mutants(in applicable_antivirals, in id, out mutants)
{
    get_mutant(id, mutant);
    applicable_antivirals.combine_antivirals(combination);
    for (comb = combination.begin(); comb != combination.end(); ++comb)
    {
    	    resistance_applied(comb, mutant, current_mutant);
        insert_into(mutants, get_id(current_mutant));
    }
}

void resistance_applied(in: it_exp_resis, join_antivirals, out: current_mutant)
{
    size_t i = 0;
    uint value;
    while (it_exp_resis->pos != join_antivirals[i].pos_resistence)
    {
        ++i;
    }
    join_antivirals[i].get_value_of_triplet(it_exp_resis->triplet, value);
    current_mutant[i] = value;
}
					\end{lstlisting}
			\item[8-] El \textbf{RF6} propone que a partir de poblaciones mutantes, se retorne la intersecci\'on 	
					entre los conjuntos de antivirales que aplican a cada poblaci\'on.\\
					\begin{itemize}
						\item[8.1] Para cada mutante (identificador) en poblaciones mutantes, se aplica el paso 
									6. Obteniendo un conjunto de \textit{ARVs} que aplica a cada mutante.
						\item[8.2] Se calcula la intersecci\'on entre los resultados obtenidos en el paso anterior, 
						es decir, se calcula la intersecci\'on entre los conjuntos de \textit{ARVs} que aplica a 
						cada poblaci\'on.
					\end{itemize}
					\begin{lstlisting}[language=C++,keywordstyle=\color{blue}, 
					       morekeywords={in, out, each}]
void get_applicable_populations(in: ids, out: applicable_antivirals)
{
    it_id = ids.begin();
    get_applicable(it_id, applicable_antivirals);
    ++it_id;
    for (; it_id != ids.end(); ++it_id)
    {
        get_applicable(it_id, current_arvs_applicable);
        intersection_set(current_arvs_applicable, applicable_antivirals);
    }
}

void intersection_set(in: current_arvs_applies, in-out: antivirals_applies)
{
    for (it_arvs_ap = antivirals_applies.begin(); it_arvs_ap != antivirals_applies.end(); 
        ++it_arvs_ap)
    {
        it_current_arvs = current_arvs_applies.begin();
        while ((it_current_arvs != current_arvs_applies.end()) && 
               (!(*it_current_arvs == *it_arvs_ap)))
        {
            ++it_current_arvs;
        }
        if (!(*it_current_arvs == *it_arvs_ap))
        {
            antivirals_applies.remove(*it_arvs_ap);
        }
     }
}
					\end{lstlisting}
			\item[9-] El \textbf{RF7} propone que a partir de un elemento de $\mathcal{P}$(ARVs) que aplique a 	
					poblaciones mutantes, calcular la uni\'on de todas las mutantes resultantes de dicha 
					aplicaci\'on.\\
					A partir de poblaciones mutantes y un conjunto de \textit{ARVs} que aplican a todas
					las poblaciones:
					\begin{itemize}
						\item [9.1] Para cada mutante (identificador) en poblaciones mutantes, se aplica el paso 	
									7.
						\item [9.2] Se guarda cada resultado del paso anterior a la lista de mutantes 	
									resultantes.
					\end{itemize}
					\begin{lstlisting}[language=C++,keywordstyle=\color{blue}, 
					       morekeywords={in, out, each}]
void get_mutants_populations(in ids, in applicable_antivirals, out all_mutants)
{
    for (it_id = ids.begin(); it_id != ids.end(); ++it_id)
    {
        get_mutants(applicable_antivirals, it_id, all_mutants);
    }
}					
					\end{lstlisting}
			\item [10-] El \textbf{RF8} propone calcular a partir de un identificador del virus, el conjunto de 
					identificadores (que representan a las mutantes) alcanzables desde dicho identificador.\\
					Dado un identificador:
					\begin{itemize}
						\item [10.1] El identificador se agrega a la pila de mutantes.
						\item [10.2] Se obtiene el identificador del tope de la pila, si \'este no pertenece al 
									conjunto resultado, se lo agrega y se aplica el paso 6.
						\item [10.3] A partir de los \textit{ARVs} obtenidos del paso anterior y el identificador 
									dado, se aplica el paso 7.
						\item [10.4] Todas las mutantes resultantes del paso anterior son puestas en la pila de 
									mutantes.
						\item [10.5] Se repite este proceso desde el punto 10.2, hasta que la pila quede vac\'ia.
								
					\end{itemize}
					\begin{lstlisting}[language=C++,keywordstyle=\color{blue}, 
					       morekeywords={in, out, each}]
void get_mutants_catch_up(in id, out mutants)
{
    stack_ids.push_front(id);
    while (!stack_ids.empty())
    {
        if (!exist_id(stack_ids.front(), mutants))
        {
            insert_into(mutants, stack_ids.front());
            get_applicable(stack_ids.front(), arvs_applicable);
            if (arvs_applicable.size() > 0)
            {
                get_mutants(arvs_applicable, stack_ids.front(), stack_ids);
            }            
        }
        stack_ids.pop_front();
    }
}
				    \end{lstlisting}
\end{itemize}


\section{Dise\~no del Sistema}
Teniendo en cuenta que este trabajo propone sumar nuevas funcionalidades a \textit{LAV}, presentaremos en detalle el dise\~no actual que posee dicha librer\'ia y explicaremos como estas nuevas funcionalidades se incorporaran a la misma.

\subsection{Dise\~no de Alto Nivel}

\subsubsection{Arquitectura de \textit{LAV}}
En esta secci\'on se describe al sistema como un conjunto de componentes y conectores que denotan las partes involucradas y la interacci\'on que existe entre dichos componentes.

\begin{figure}[htb]
\centering
\includegraphics[width=1\textwidth]{./Imagenes/arquitectura_lav.pdf}
\caption{Arquitectura de \textit{LAV}}
\label{fig:arquitecturaLAV}
\end{figure}

Como se puede observar en la Figura \ref{fig:arquitecturaLAV} el dise\~no divide al sistema en tres partes: las librer\'ias externas (BioPP, MiLi), la Base de Datos (Antiviral Data Base) y el n\'ucleo del sistema (\textit{LAV}). De esta forma, se obtiene un sistema compacto, robusto y modular que garantiza poco acoplamiento entre sus partes. Los componentes involucrados en este proyecto son \textbf{Possible Mutants}, \textbf{Therapy Generator} y \textbf{Antivirals Selector}, donde el primero es un componente agregado por este proyecto y a los dos restantes se le incorporaron funcionalidades que ser\'an detalladas en las siguientes secciones.

\subsubsection*{Cat\'alogo de Componentes}

\begin{itemize}
\item \textbf{Possible Mutants}: Nuevo componente que permite definir a trav\'es de la \textit{Base de Datos} de
								\textit{ARVs} todas las posibles mutantes que se pueden generar y representarlas 	
								como un n\'umero en base mixta al cual se le asocia un identificador un\'ivoco. 
\item \textbf{Therapy Generator}: Componente utilizado para calcular diferentes terapias para una secuencia 				mutante, teniendo en cuenta las diferentes pol\'iticas de combinaci\'on y el ``Ranker'' de 						Antivirales.
\item \textbf{Antivirals Selector}: Se encarga de obtener el conjunto de Antirretrovirales que aplican a una 					secuencia nucle\'otida.
\item \textbf{Combinatory Engine}: Motor combinatorio de Antirretrovirales. 
\item \textbf{Ranker}: Componente encargado de mantener un \textit{ranking} con las mejores terapias, de 			acuerdo a un sistema de puntuaci\'on. 
\item \textbf{Antiviral Data Base}: Base de Datos que contiene la informaci\'on de todos los Antirretrovirales.
\end{itemize}

\subsection{Dise\~no de Bajo Nivel}

\subsubsection{Interfaces, Clases y Estructuras de \textit{LAV}}
En la Figura \ref{fig:clases_estructuras} se muestra un diagrama conteniendo las Interfaces, Clases y Estructuras de \textit{LAV} y las relaciones que existen entre ellas.

\begin{figure}[htb]
\centering
\includegraphics[width=1\textwidth]{./Imagenes/clases_estructuras.pdf}
\caption{Interfaz, Clases y Estructuras de \textit{LAV}}
\label{fig:clases_estructuras}
\end{figure}

\subsubsection{Descripci\'on de Interfaces, Clases y Estructuras existentes}

\begin{itemize}
\item \textbf{Antiviral}: Interfaz Antiviral. Define un conjunto de funcionalidades b\'asicas de un 						Antirretroviral.
\item \textbf{SequenceSet}: Tipo de Dato que define un conjunto de secuencias Nucleot\'idicas.
\item \textbf{MutantDist}: Cuando un antirretroviral aplica lo hace con una distancia gen\'etica 							determinada. La clase \emph{MutantDist} captura al conjunto de mutantes que cumplen la distancia 						m\'inima considerada al aplicarse un Antirretroviral.
\item \textbf{DistanceMatrix}: La matriz de distancias g\'eneticas define al valor entre dos nucle\'otidos. 				Esta implementaci\'on deriva de BioPP.
\item \textbf{ResisBasedAntiviral}: Clase que implementa la interfaz \textit{Antiviral}.
\item \textbf{ResistencePosition}: Estructura que define una posici\'on de resistencia particular para un 					amino\'acido.
\item \textbf{AntiviralSet}: Estructura que define un conjunto de Antivirales y operaciones para \'este.
\item \textbf{Mutant}: Tipo de Dato que define una secuencia y el Antirretroviral que se aplic\'o.
\item \textbf{AntiviralSelector}: Clase que provee la funcionalidad de colocar en un \textit{AntiviralSet} 					los Antirretrovirales que aplican a una secuencia.
\item \textbf{NucSequence}: Clase que proviene de BioPP. Permite representar una secuencia de nucle\'otidos 				con m\'etodos asociados para su manejo. Se representa como una cadena con cuatro posibles 						caracteres \emph{(A,T,C,G)}.
\end{itemize}

\subsubsection{Descripci\'on de Tipos, Clases y Estructuras incorporadas y/o modificadas}
\begin{itemize}
\label{NuevosMetodos}
\item \textbf{AntiviralSet}: Estructura existente en \textit{LAV} a la cual se le agregaron las siguientes funcionalidades, utilizadas en la soluci\'on propuesta \ref{SP}:

\begin{itemize}
	\item \textit{join\_antivirals()}: M\'etodo que permite agrupar todas las resistencias (amino\'acidos) de la 	
									base de datos de antivirales seg\'un la posici\'on en la que aplican.
									Utilizado en el paso 1 de la soluci\'on propuesta.
	\item \textit{get\_id\_from\_sequence()}: M\'etodo que retorna el identificador de un \textit{NucSequence}.
	\item \textit{get\_sequence\_from\_id()}: M\'etodo que retorna la \textit{NucSequence} correspondiente a un 	
											identificador dado.
	\item \textit{get\_applicable()}: M\'etodo retorna los antivirales que aplican a una secuencia mutante.
								   Detallado en el paso 6 de la soluci\'on propuesta.
	\item \textit{get\_mutants()}: M\'etodo que dado un identificador y un conjunto de ARVs que aplican al 	
									identificador, retorna las mutantes resultantes de dicha aplicaci\'on.
									Detallado en el paso 7 de la soluci\'on propuesta.
	\item \textit{get\_applicable\_populations()}: M\'etodo que retorna un conjunto de antivirales que aplican a 	
											poblaciones de mutantes.
											Detallado en el paso 8 de la soluci\'on propuesta.
	\item \textit{get\_mutants\_populations()}: M\'etodo que dado un conjunto de poblaciones mutantes y un conjunto 											de ARVs que aplica a la poblaci\'on, retorna las mutantes resultantes de
										dicha aplicaci\'on.
										Detallado en el paso 9 de la soluci\'on propuesta.
	\item \textit{get\_mutants\_catch\_up()}: M\'etodo que dado un identificador, retorna todas las mutantes 
												alcanzables desde dicho identificador. 
											 Detallado en el paso 10 de la soluci\'on propuesta.
\end{itemize}
\item \textbf{ResisBasedAntiviral}: Clase existente en \textit{LAV} a la cual se le agreg\'o el siguiente 
									m\'etodo:
	\begin{itemize}
		\item \textit{min\_dist\_to\_antiviral()}: Retorna la m\'inima distancia gen\'etica entre el antiviral 
													corriente y un cod\'on dado.
												Utilizado en el paso 6.3 de la soluci\'on propuesta.
	\end{itemize} 


\item \textbf{ResistencePosition}: Clase existente en \textit{LAV} a la cual se le agreg\'o el siguiente 
									m\'etodo:
	\begin{itemize}
		\item \textit{min\_dist\_to\_resistance()}: Retorna la m\'inima distancia gen\'etica entre la resistencia 
													corriente y un cod\'on dado.
													Utilizado en el paso 6.3 de la soluci\'on propuesta.
	\end{itemize}	 


\item \textbf{PossibleMutants}: Nueva clase que permite calcular todas las mutantes posibles, definirlas como un n\'umero en base mixta y asociarles un identificador univoco a cada una de ellas. Tambi\'en provee los m\'etodos necesarios para pasar de un identificador a la mutante que \'este representa y viceversa.\\
En la figura \ref{fig:classPossibleMutants} se muestra un diagrama de la clase con los atributos y m\'etodos que \'esta contiene, utilizados en la soluci\'on  \ref{SP}:

\begin{figure}[htb]
\centering
\includegraphics[width=0.7\textwidth]{./Imagenes/classPossibleMutants.pdf}
\caption{Clase PossibleMutants}
\label{fig:classPossibleMutants}
\end{figure}
\pagebreak
\begin{itemize}
	\item \textit{Atributos}:
		\begin{itemize}
			\item \textit{mutantSize}: Tama\~no de la mutante (longitud del n\'umero en base mixta).\\ 
			Paso n\'umero 2.1 de la soluci\'on propuesta.
			\item \textit{mutantsBases}: Vector que contiene las bases para el n\'umero en base mixta 
			(mutante).\\
			Paso n\'umero 2.2 de la soluci\'on propuesta.
			\item \textit{mutantsCoefficients}: Vector que contiene los coeficientes.\\
			Paso n\'umero 4.1 de la soluci\'on propuesta.
			\item \textit{maxNumberMutants}: N\'umero m\'aximo de mutantes posibles.\\
			Paso n\'umero 3 de la soluci\'on propuesta.
		\end{itemize}	
	\item \textit{M\'etodos}:
		\begin{itemize}
			\item \textit{get\_id()}: Retorna el identidicador para una mutante dada.\\
			Paso n\'umero 4.2 de la soluci\'on propuesta.
			\item \textit{get\_mutant()}: Retorna la mutante que representa un identificador dado.\\
			Paso n\'umero 5 de la soluci\'on propuesta.
			\item \textit{mutant\_to\_triplet()}: Retorna una mutante (posici\'on, triplete) a partir de una 															mutante en base mixta.\\
			Paso n\'umero 6.2 de la soluci\'on propuesta.
			\item \textit{get\_mutant\_bases()}: Calcula cada base del vector mutantsBases.\\
			Paso n\'umero 2.2 de la soluci\'on propuesta.	
		\end{itemize}
\end{itemize}


\item \textbf{TripletPosition}: Nuevo tipo que permite representar a una mutante como una lista que contiene: (posici\'on, cod\'on). Utilizado en el paso n\'umero 6.2 de la soluci\'on propuesta \ref{SP}.

\begin{figure}[htb]
\centering
\includegraphics[width=0.4\textwidth]{./Imagenes/structTripletPosition.pdf}
\caption{Estructura TripletPosition}
\label{fig:structTripletPosition}
\end{figure}

\item \textbf{PosAminoacidTriplet y AminoacidTriplets}: Nuevas estructuras que permiten agrupar las resistencias de todos los antivirales seg\'un su posici\'on, conteniendo el/los amino\'acido/s en dicha posici\'on y los codones correspondientes de cada amino\'acido. Utilizado en el paso n\'umero 1 de la soluci\'on propuesta \ref{SP}.

\begin{figure}[htb]
\centering
\includegraphics[width=0.6\textwidth]{./Imagenes/structPosAminoacidsTriplets.pdf}
\caption{Estructura PosAminoacidsTriplets}
\label{fig:structPosAminoacidsTriplets}
\end{figure}

\end{itemize}